Please address the comments from this code review:

## Overall Comments
- In `cosyvoice_tts_source.py`, `SpeechSynthesizer` is imported unconditionally at module import time, unlike the guarded import pattern used in `qwen_tts_realtime_source.py`; consider wrapping this import in a `try/except ImportError` with a clear error message so environments without `dashscope` don’t crash on import.
- The built-in patterns in `TTSTextFilter.BUILTIN_PATTERNS` aggressively strip all `*...*` and `**...**` segments, which may remove legitimate markdown emphasis rather than just emotion markers; consider either narrowing these regexes or making markdown-based stripping configurable to avoid unexpected loss of content.

## Individual Comments

### Comment 1
<location path="astrbot/core/provider/sources/qwen_tts_realtime_source.py" line_range="145-154" />
<code_context>
+            f.write(audio_bytes)
+        return path
+
+    async def _synthesize(self, text: str) -> bytes | None:
+        """Use CosyVoice SpeechSynthesizer to synthesize speech."""
+        loop = asyncio.get_running_loop()
</code_context>
<issue_to_address>
**issue (bug_risk):** Close the WebSocket session and use the thread-safe drain helper when assembling audio in `_synthesize`.

`_synthesize` reads `callback.audio_chunks` directly while the WebSocket thread may still be appending, bypassing the `drain_audio_chunks()` lock, and it never explicitly closes `QwenTtsRealtime`.

To align with the streaming path and avoid races/resource leaks, you could do something like:

```python
try:
    await loop.run_in_executor(None, _connect_and_send)
    finished = callback.wait_for_finished(timeout=self.timeout)
    # ... error/timeout handling ...
    pcm_data = b"".join(callback.drain_audio_chunks())
    if not pcm_data:
        return None
    return self._pcm_to_wav(pcm_data, sample_rate=24000)
finally:
    try:
        await loop.run_in_executor(None, qwen_tts.close)
    except Exception:
        pass
```

This keeps audio access thread-safe and ensures the WebSocket is closed even on error paths.
</issue_to_address>

### Comment 2
<location path="astrbot/core/provider/sources/cosyvoice_tts_source.py" line_range="16" />
<code_context>
+import os
+import uuid
+
+from dashscope.audio.tts_v2 import AudioFormat, SpeechSynthesizer
+
+from astrbot.core import logger
</code_context>
<issue_to_address>
**issue (bug_risk):** Guard the CosyVoice DashScope import similarly to the Qwen provider to avoid hard ImportError.

This provider imports `SpeechSynthesizer` at module import time without a `try/except`, so if the DashScope TTS v2 API or `audio.tts_v2` isn’t available, importing this module will raise and can break provider loading.

To align with Qwen and fail gracefully, wrap the import in a `try/except ImportError`, set `AudioFormat` and `SpeechSynthesizer` to `None` on failure, and then have `_synthesize` / `get_audio` raise a clear `RuntimeError` when the SDK capability is missing.
</issue_to_address>

### Comment 3
<location path="astrbot/core/utils/tts_text_filter.py" line_range="52" />
<code_context>
+        return result.strip()
+
+
+class FilteredQueue:
+    """异步队列包装器，在 get() 时自动过滤文本。
+
</code_context>
<issue_to_address>
**issue (complexity):** Consider replacing the speculative FilteredQueue wrapper with a simple filtered_get coroutine to keep behavior explicit and avoid a partial queue-like abstraction.

You can keep the text‑filter functionality while avoiding the speculative `FilteredQueue` abstraction and its partial queue façade.

Instead of wrapping `asyncio.Queue` in a class that shadows part of its API and hides the drop behavior inside `get()`, extract a focused helper coroutine that can be used wherever streaming is actually needed:

```python
class TTSTextFilter:
    ...
    @classmethod
    def apply(cls, text: str, custom_rules: list[str] | None = None) -> str:
        ...
        return result.strip()
```

Replace `FilteredQueue` with:

```python
async def filtered_get(
    queue: asyncio.Queue,
    custom_rules: list[str] | None = None,
) -> str | None:
    """从队列中获取一个元素；如果是字符串则应用 TTS 过滤。

    返回值：
    - None: 队列中取出了 None，呼叫方可认为是结束信号。
    - 非空字符串: 过滤后的文本。
    - 其他类型: 原样返回（例如用于控制消息）。
    """
    while True:
        item = await queue.get()
        if item is None:
            return None
        if isinstance(item, str):
            filtered = TTSTextFilter.apply(item, custom_rules)
            if filtered:
                return filtered
            # 空字符串时继续从队列中取下一个
            continue
        return item
```

Usage in a future streaming TTS consumer stays explicit and predictable:

```python
while True:
    text = await filtered_get(raw_text_queue, custom_rules)
    if text is None:
        break
    # 使用过滤后的 text 进行 TTS
```

This keeps:

- All current filtering behavior.
- No partial queue interface to maintain.
- No surprising `get()` semantics on a “queue‑like” object; the drop/loop behavior is clear at the call site.
</issue_to_address>